import axios from 'axios'
import router from '../router'
import authAPI from './auth.js'

// 创建axios实例
const service = axios.create({
  // 根据环境自动切换基础URL
  baseURL: import.meta.env.MODE === 'production' ? 'http://14.103.171.191:8080' : 'http://localhost:8080',
  // 请求超时时间
  timeout: 10000
})

// 全局变量，用于管理token刷新状态
let isRefreshing = false
// 存储刷新token期间的请求队列
let requestQueue = []

// 请求拦截器
service.interceptors.request.use(
  config => {
    // 在这里可以添加token等认证信息
    const token = localStorage.getItem('accessToken')
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`
    }
    return config
  },
  error => {
    // 使用更具描述性的错误信息
    console.error('请求错误:', error.message || error)
    return Promise.reject(error)
  }
)

// 响应拦截器
service.interceptors.response.use(
  response => {
    // 在这里可以统一处理响应数据
    const res = response.data
    console.log('API响应:', res)
    
    // 检查是否是标准格式的响应
    if (res.code !== undefined) {
      // 根据后端定义的状态码体系判断成功响应
      // 20000-20003 为成功状态码
      if ((res.code >= 20000 && res.code <= 20003) || res.type === 'SUCCESS' || res.success === true) {
        // 请求成功，返回响应
        return res
      } else {
        // 非关键错误也返回数据，以便前端处理
        console.warn('API返回非标准成功格式:', res)
        return res
      }
    }
    // 非标准格式的响应直接返回
    return res
  },
  error => {
    // 使用后端返回的错误信息进行日志记录
    console.error('响应错误:', error.response?.data?.message || error.message || error)
    // 在这里可以统一处理错误
    if (error.response) {
      switch (error.response.status) {
        case 401:
          // 处理未授权错误 - 尝试刷新token
          // 使用更具描述性的错误信息
          console.error('未授权，尝试刷新token:', error.message || error)
          const originalRequest = error.config
          
          // 防止重复请求
          if (!originalRequest._retry) {
            originalRequest._retry = true
            
            // 如果正在刷新token，则将请求加入队列等待
            if (isRefreshing) {
              return new Promise((resolve) => {
                requestQueue.push((token) => {
                  originalRequest.headers.Authorization = `Bearer ${token}`
                  resolve(service(originalRequest))
                })
              })
            }
            
            isRefreshing = true
            
            // 尝试刷新token
            return authAPI.refreshToken(localStorage.getItem('refreshToken'))
              .then(response => {
                // 检查刷新是否成功 - 支持20000-20003成功状态码
                if ((response.code >= 20000 && response.code <= 20003) && response.data) {
                  // 更新本地存储的token
                  const newAccessToken = response.data.accessToken
                  const newRefreshToken = response.data.refreshToken
                  localStorage.setItem('accessToken', newAccessToken)
                  localStorage.setItem('refreshToken', newRefreshToken)
                  
                  // 更新请求头
                  service.defaults.headers.common['Authorization'] = `Bearer ${newAccessToken}`
                  
                  // 处理队列中的请求
                  requestQueue.forEach(cb => cb(newAccessToken))
                  requestQueue = []
                  
                  // 重试当前请求
                  originalRequest.headers.Authorization = `Bearer ${newAccessToken}`
                  return service(originalRequest)
                } else {
                  // 刷新失败，不需要抛出自定义错误，使用后端返回的错误信息
                return Promise.reject(response)
                }
              })
              .catch(err => {
                // 使用更具描述性的错误信息
            console.error('Token刷新错误:', err.message || err)
                // 清除本地存储并重定向到登录页
                localStorage.removeItem('accessToken')
                localStorage.removeItem('refreshToken')
                localStorage.removeItem('userInfo')
                router.push('/login')
                return Promise.reject(err)
              })
              .finally(() => {
                isRefreshing = false
              })
          }
          
          break
        case 403:
          // 处理禁止访问错误
          console.error('拒绝访问:', error.response?.data?.message || error.message)
          break
        case 404:
          // 处理资源不存在错误
          console.error('请求资源不存在:', error.response?.data?.message || error.message)
          break
        case 500:
          // 处理服务器错误
          console.error('服务器错误:', error.response?.data?.message || error.message)
          break
        default:
          console.error('请求失败:', error.response?.data?.message || error.message)
      }
    }
    // 返回错误响应，让前端可以处理部分成功的情况
    if (error.response && error.response.data) {
      return Promise.resolve(error.response.data)
    }
    return Promise.reject(error)
  }
)

export default service